const Controller = require('egg').Controller;


class customer extends Controller {
    /**
     * 菜单跳转
     * @returns {Promise<void>}
     */
    async to(){
        const {app,ctx,service} = this;
        await ctx.render('/admin/customer_query.ejs',{});
    }

    /**
     * 跳转新增页面
     * @returns {Promise<void>}
     */
    async tonew(){
        const {app,ctx,service} = this;
        await ctx.render('/admin/customer_new.ejs',{});
    }

    /**
     * 跳转编辑页面
     * @returns {Promise<void>}
     */
    async toedit(){
        const {app,ctx,service} = this;
        //编辑id
        let id = ctx.request.query.id;
        await ctx.render('/admin/customer_edit.ejs',{id:id});
    }

    /**
     * 跳转详情页面
     * @returns {Promise<void>}
     */
    async todetail(){
        const {app,ctx,service} = this;
        //编辑id
        let id = ctx.request.query.id;
        await ctx.render('/admin/customer_detail.ejs',{id:id});
    }

    /**
     * 查询接口
     * isPage 是否分页
     * limit offset 每页限制数 偏移量
     * search 搜索项
     * /admin/接口
     * type get
     * @returns {Promise<void>}
     */
    async index(){
        const {app,ctx,service} = this;
        //取get请求参数
        let param = ctx.query;
        //初始化变量 用于请求参数中缺失部分参数时不至于导致报错
        let limit = 10;
        let offset = 0;
        let search = '%%';
        let isPage = 'true';
        let forbidden = ['0','1'];

        //循环请求参数 赋值 到变量
        app.lodash.forEach(param,(v,k)=>{
            if(!app.lodash.isEmpty(v)){
                switch (k) {
                    case 'pageSize':
                        limit = parseInt(v);break;
                    case 'limit':
                        limit = parseInt(v);break;
                    case 'page':
                        offset = parseInt((v - 1) * limit);break;
                    case 'search':
                        search = v;break;
                    case 'isPage':
                        isPage = v;break;
                    case 'forbidden':
                        forbidden = [v];break;
                }
            }
        })

        //调取service获取结果
        let rs = await service.customerService.index(offset,limit,search,isPage,forbidden);

        //返回
        ctx.body = {
            code : 0,
            data : rs.rows,
            count: rs.count,
            msg : ''
        }
    }

    /**
     * 新增接口
     * /admin/接口/new
     * type post
     * @returns {Promise<void>}
     */
    async create(){
        const {app,ctx,service} = this;
        //获取post请求参数
        let param = ctx.request.body.data;

        //创建验证规则
        const rule = {
            name:'required',
            code:'required|alpha',//仅支持字母
            path:'required',
        };
        //验证 验证成功 err为undefined 失败则为错误信息
        const err = await app.validator.validate(param,rule);
        //判断err是否为空
        if(!app.lodash.isEmpty(err)){
            //非空说明 验证失败,抛出401错误,即缺失参数或参数不合规范
            ctx.throw(401,err[0].field+' -- '+err[0].message);
        }

        //调用service获取结果
        let rs = await service.customerService.create(param);

        //判断新增是否成功
        //此处只会捕捉到因为记录已存在而添加失败的错误 其他错误此处无法捕捉,由最外层的错误捕捉来处理
        if(!rs){
            //失败 只有一个原因,既是记录已存在
            ctx.throw(501,'该记录已存在');
        }

        //返回
        ctx.body = {
            code : 200,
            data : {},
            msg : ''
        }
    }

    /**
     * 删除接口
     * /admin/接口/:id
     * type delete
     * @returns {Promise<void>}
     */
    async destroy(){
        const {app,ctx,service} = this;
        //获取url参数
        let param = ctx.params;

        //创建规则
        const rule = {
            id:'required'
        };
        //验证
        const err = await app.validator.validate(param,rule);
        //判断验证结果
        if(!app.lodash.isEmpty(err)){
            //抛出验证错误
            ctx.throw(401,err[0].field+' -- '+err[0].message);
        }

        //调用service获取结果
        let rs = await service.customerService.destroy(param);

        //判断处理是否成功
        if(!rs){
            //否 抛出处理失败错误
            ctx.throw(501,'记录删除失败');
        }

        //返回
        ctx.body = {
            code : 200,
            data : {},
            msg : ''
        }
    }

    /**
     * 单个记录查询接口
     * /admin/接口/:id
     * type : get
     * @returns {Promise<void>}
     */
    async show(){
        const {app,ctx,service} = this;
        //获取url请求参数
        let param = ctx.params;

        //创建规则
        const rule = {
            id:'required'
        };
        //验证
        const err = await app.validator.validate(param,rule);
        //判断验证结果
        if(!app.lodash.isEmpty(err)){
            //抛出验证错误信息
            ctx.throw(401,err[0].field+' -- '+err[0].message);
        }

        //调用service获取结果
        let rs = await service.customerService.show(param);

        //判断处理是否成功
        if(app.lodash.isEmpty(rs)){
            //失败 抛出错误信息
            ctx.throw(501,'记录查询失败');
        }

        //返回
        ctx.body = {
            code : 200,
            data : rs,
            msg : ''
        }
    }

    /**
     * 更新接口
     * /admin/接口/:id
     * type put
     * @returns {Promise<void>}
     */
    async update(){
        const {app,ctx,service} = this;
        //获取post请求参数
        let param = ctx.request.body.data;
        //获取url请求参数
        param.id = ctx.params.id;

        //创建规则
        const rule = {
            id:'required',
            name:'required',
            code:'required|alpha',//仅支持字母
            path:'required',//仅支持字母
        };
        //验证
        const err = await app.validator.validate(param,rule);
        //判断验证结果
        if(!app.lodash.isEmpty(err)){
            //抛出验证错误信息
            ctx.throw(401,err[0].field+' -- '+err[0].message);
        }

        //调用service获取结果
        let rs = await service.customerService.update(param);

        //判断处理结果
        if(!rs){
            //抛出处理失败错误信息
            ctx.throw(501,'记录查询失败');
        }

        //返回
        ctx.body = {
            code : 200,
            data : rs,
            msg : ''
        }
    }

    /**
     * 更新接口
     * /admin/接口/:id/edit
     * type get
     * @returns {Promise<void>}
     */
    async edit(){
        const {app,ctx,service} = this;
        //获取url参数
        let url_param = ctx.params;
        //获取get参数
        let param = ctx.query;
        //创建规则
        const rule = {
            id:'required'
        };
        //验证
        const err = await app.validator.validate(url_param,rule);
        //判断验证结果
        if(!app.lodash.isEmpty(err)){
            //抛出验证错误信息
            ctx.throw(401,err[0].field+' -- '+err[0].message);
        }

        param.id = url_param.id;

        let {password} = param;
        if(!app.lodash.isEmpty(password)){
            param.password = await service.utils.md5(password);
        }

        //调用service获取结果
        let rs = await service.customerService.edit(param);

        //判断处理结果
        if(!rs){
            //抛出处理失败错误信息
            ctx.throw(501,'记录查询失败');
        }

        //返回
        ctx.body = {
            code : 200,
            data : rs,
            msg : ''
        }
    }
}

module.exports = customer;
